home *** CD-ROM | disk | FTP | other *** search
/ Aminet 37 / Aminet 37 (2000)(Schatztruhe)[!][Jun 2000].iso / Aminet / dev / lang / sofa.lha / sofa / smalleiffel / lib_se / manifest_string_pool.e < prev    next >
Text File  |  2000-03-25  |  10KB  |  342 lines
  1. --          This file is part of SmallEiffel The GNU Eiffel Compiler.
  2. --          Copyright (C) 1994-98 LORIA - UHP - CRIN - INRIA - FRANCE
  3. --            Dominique COLNET and Suzanne COLLIN - colnet@loria.fr
  4. --                       http://SmallEiffel.loria.fr
  5. -- SmallEiffel is  free  software;  you can  redistribute it and/or modify it
  6. -- under the terms of the GNU General Public License as published by the Free
  7. -- Software  Foundation;  either  version  2, or (at your option)  any  later
  8. -- version. SmallEiffel is distributed in the hope that it will be useful,but
  9. -- WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  10. -- or  FITNESS FOR A PARTICULAR PURPOSE.   See the GNU General Public License
  11. -- for  more  details.  You  should  have  received a copy of the GNU General
  12. -- Public  License  along  with  SmallEiffel;  see the file COPYING.  If not,
  13. -- write to the  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  14. -- Boston, MA 02111-1307, USA.
  15. --
  16. class MANIFEST_STRING_POOL
  17.    --
  18.    -- Unique global object in charge of MANIFEST_STRING used.
  19.    --
  20.  
  21. inherit GLOBALS;
  22.  
  23. feature {MANIFEST_STRING}
  24.  
  25.    register(ms: MANIFEST_STRING): STRING is
  26.          -- To register a runnable one.
  27.          -- Choose the appropriate mangling.
  28.       require
  29.          ms /= Void;
  30.          not small_eiffel.is_ready
  31.       local
  32.          x: INTEGER;
  33.       do
  34.          header.copy("ms");
  35.          x := ms.start_position.base_class.id;
  36.          x.append_in(header);
  37.          header.extend('_');
  38.          x := ms.to_string.hash_code;
  39.          x.append_in(header);
  40.          from
  41.          until
  42.             not mangling_dictionary.has(header)
  43.          loop
  44.             header.extend('a');
  45.          end;
  46.          Result := header.twin;
  47.          mangling_dictionary.put(ms,Result);
  48.       end;
  49.  
  50. feature {SMALL_EIFFEL}
  51.  
  52.    falling_down is
  53.       do
  54.          if mangling_dictionary.count > 0 then
  55.             type_string.set_at_run_time;
  56.          end;
  57.       end;
  58.  
  59.    c_define1(string_at_run_time: BOOLEAN) is
  60.       do
  61.          if not string_at_run_time then
  62.             cpp.put_string(
  63.                "typedef struct S7 T7;%N%
  64.                %struct S7{T9 _storage;T2 _count;T2 _capacity;};%N");
  65.          end;
  66.       end;
  67.  
  68.    c_define2(string_at_run_time: BOOLEAN) is
  69.       require
  70.          cpp.on_c
  71.       local
  72.          i, j, function_count, mdc: INTEGER;
  73.          ms: MANIFEST_STRING;
  74.       do
  75.          mdc := mangling_dictionary.count;
  76.          echo.print_count("Manifest String",mdc);
  77.          if mdc > 0 then
  78.             from -- For *.h :
  79.                i := 1;
  80.             until
  81.                i > mdc
  82.             loop
  83.                ms := mangling_dictionary.item(i);
  84.                header.copy(fz_t7_star);
  85.                header.append(ms.mangling);
  86.                cpp.put_extern1(header);
  87.                i := i + 1;
  88.             end;
  89.          end;
  90.          define_se_ms(string_at_run_time);
  91.          if mdc > 0 then
  92.             from -- For *.c :
  93.                i := 1;
  94.                function_count := 1;
  95.             until
  96.                function_count > 1 and then i > mdc
  97.             loop
  98.                header.copy(fz_void);
  99.                header.extend(' ');
  100.                header.append(fz_se_msi);
  101.                function_count.append_in(header);
  102.                header.append(fz_c_void_args);
  103.                from
  104.                   body.clear;
  105.                   j := nb_ms_per_function;
  106.                until
  107.                   j = 0 or else i > mdc
  108.                loop
  109.                   ms := mangling_dictionary.item(i);
  110.                   body.append(ms.mangling);
  111.                   body.append("=se_ms(");
  112.                   ms.count.append_in(body);
  113.                   body.extend(',');
  114.                   string_to_c_code(ms.to_string,body);
  115.                   body.append(fz_14);
  116.                   j := j - 1;
  117.                   i := i + 1;
  118.                end;
  119.                function_count := function_count + 1;
  120.                if i <= mdc then
  121.                   body.append(fz_se_msi);
  122.                   function_count.append_in(body);
  123.                   body.append(fz_c_no_args_procedure);
  124.                end;
  125.                cpp.put_c_function(header,body);
  126.            if function_count \\ 5 = 0 then
  127.           cpp.padding_here;
  128.            end;
  129.             end;
  130.         cpp.padding_here;
  131.          end;
  132.       ensure
  133.          cpp.on_c
  134.       end;
  135.  
  136. feature {C_PRETTY_PRINTER}
  137.  
  138.    string_to_c_code(s: STRING; c_code: STRING) is
  139.       local
  140.          i: INTEGER;
  141.       do
  142.          c_code.extend('%"');
  143.          from
  144.             i := 1;
  145.          until
  146.             i > s.count
  147.          loop
  148.             character_to_c_code(s.item(i),c_code);
  149.             i := i + 1;
  150.          end;
  151.          c_code.extend('%"');
  152.       end;
  153.  
  154.    character_to_c_code(c: CHARACTER; c_code: STRING) is
  155.       do
  156.          if c = '%N' then
  157.             c_code.extend('\');
  158.             c_code.extend('n');
  159.          elseif c = '\' then
  160.             c_code.extend('\');
  161.             c_code.extend('\');
  162.          elseif c = '%"' then
  163.             c_code.extend('\');
  164.             c_code.extend('%"');
  165.          elseif c = '%'' then
  166.             c_code.extend('\');
  167.             c_code.extend('%'');
  168.          elseif c.code < 32 or else 122 < c.code then
  169.             c_code.extend('\');
  170.             c.code.to_octal.append_in(c_code);
  171.             c_code.extend('%"');
  172.             c_code.extend('%"');
  173.          else
  174.             c_code.extend(c);
  175.          end;
  176.       end;
  177.  
  178.    c_call_initialize is
  179.       require
  180.          cpp.on_c
  181.       do
  182.          if mangling_dictionary.count > 0 then
  183.             cpp.put_string(fz_se_msi);
  184.             cpp.put_character('1');
  185.             cpp.put_string(fz_c_no_args_procedure);
  186.          end;
  187.       ensure
  188.          cpp.on_c
  189.       end;
  190.  
  191. feature {PROC_CALL_1}
  192.  
  193.    used_for_c_inline(ms: MANIFEST_STRING) is
  194.       require
  195.          ms /= Void
  196.       local
  197.          mangling: STRING;
  198.       do
  199.          mangling := ms.mangling;
  200.          if mangling_dictionary.has(mangling) then
  201.             mangling_dictionary.remove(mangling);
  202.          end;
  203.       end;
  204.  
  205. feature {GC_HANDLER}
  206.  
  207.    define_manifest_string_mark is
  208.       local
  209.          i, mdc, ms_count, function_count: INTEGER;
  210.          ms: MANIFEST_STRING;
  211.       do
  212.          mdc := mangling_dictionary.count;
  213.          function_count := 1;
  214.          define_manifest_string_mark_header(function_count);
  215.          from
  216.             i := 1;
  217.          until
  218.             i > mdc
  219.          loop
  220.             if ms_count > 300 then
  221.                ms_count := 0;
  222.                function_count := function_count + 1;
  223.                cpp.put_string(fz_manifest_string_mark);
  224.                cpp.put_integer(function_count);
  225.                cpp.put_string(fz_c_no_args_procedure);
  226.                cpp.put_string(fz_12);
  227.                define_manifest_string_mark_header(function_count);
  228.             end;
  229.             ms := mangling_dictionary.item(i);
  230.             cpp.put_string("((rsoh*)(");
  231.             cpp.put_string(ms.mangling);
  232.             cpp.put_string(
  233.                "->_storage)-1)->header.magic_flag=RSOH_MARKED;%N");
  234.             ms_count := ms_count + 1;
  235.             i := i + 1;
  236.          end;
  237.          cpp.put_string(fz_12);
  238.       end;
  239.  
  240. feature {JVM}
  241.  
  242.    jvm_define_fields is
  243.       local
  244.          cp: like constant_pool;
  245.          ms: MANIFEST_STRING;
  246.          name_idx, string_idx, i, mdc: INTEGER;
  247.       do
  248.          mdc := mangling_dictionary.count;
  249.          if mdc > 0 then
  250.             cp := constant_pool;
  251.             string_idx := cp.idx_eiffel_string_descriptor;
  252.             from
  253.                i := 1;
  254.             until
  255.                i > mdc
  256.             loop
  257.                ms := mangling_dictionary.item(i);
  258.                name_idx := cp.idx_utf8(ms.mangling);
  259.                field_info.add(9,name_idx,string_idx);
  260.                i := i + 1;
  261.             end;
  262.          end;
  263.       end;
  264.  
  265.    jvm_initialize_fields is
  266.       local
  267.          cp: like constant_pool;
  268.          ca: like code_attribute;
  269.          ms: MANIFEST_STRING;
  270.          i, mdc: INTEGER;
  271.       do
  272.          mdc := mangling_dictionary.count;
  273.          if mdc > 0 then
  274.             cp := constant_pool;
  275.             ca := code_attribute;
  276.             from
  277.                i := 1;
  278.             until
  279.                i > mdc
  280.             loop
  281.                ms := mangling_dictionary.item(i);
  282.                ca.opcode_push_manifest_string(ms.to_string);
  283.                ca.opcode_putstatic(ms.fieldref_idx,-1);
  284.                i := i + 1;
  285.             end;
  286.          end;
  287.       end;
  288.  
  289. feature {NONE}
  290.  
  291.    mangling_dictionary: DICTIONARY[MANIFEST_STRING,STRING] is
  292.       once
  293.          !!Result.with_capacity(4096);
  294.       end;
  295.  
  296.    body: STRING is
  297.       once
  298.          !!Result.make(2048);
  299.       end;
  300.  
  301.    define_se_ms(string_at_run_time: BOOLEAN) is
  302.       do
  303.          header.copy("T7*se_ms(int c,char*e)");
  304.          body.copy("T7*s=");
  305.          gc_handler.new_manifest_string_in(body,string_at_run_time);
  306.          body.append(
  307.             "s->_count=c;%N%
  308.             %s->_capacity=c+1;%N%
  309.             %s->_storage=((T9)");
  310.          gc_handler.new_native9_in(body,string_at_run_time);
  311.          body.append(
  312.             "(c+1));%N%
  313.             %memcpy(s->_storage,e,c);%N%
  314.             %return s;");
  315.          cpp.put_c_function(header,body);
  316.          --
  317.          cpp.put_c_function("T7*se_string_from_external_copy(char*e)",
  318.             "/* Creation of an Eiffel STRING by copying C string e. */%N%
  319.             %return se_ms(strlen(e),e);");
  320.       end;
  321.  
  322.    define_manifest_string_mark_header(number: INTEGER) is
  323.       do
  324.          header.copy(fz_void);
  325.          header.extend(' ');
  326.          header.append(fz_manifest_string_mark);
  327.          number.append_in(header);
  328.          header.append(fz_c_void_args);
  329.          cpp.put_c_heading(header);
  330.       end;
  331.  
  332.    fz_manifest_string_mark: STRING is "manifest_string_mark";
  333.  
  334.    header: STRING is "................................";
  335.  
  336.    fz_se_msi: STRING is "se_msi";
  337.  
  338.    nb_ms_per_function: INTEGER is 50;
  339.  
  340. end -- MANIFEST_STRING_POOL
  341.  
  342.